Pogojni stavki I

Indeks telesne mase

1. podnaloga

ITM oz. indeks telesne mase je številka, s katero lahko v grobem ocenimo stanje prehranjenosti pri odraslih ljudeh. Če je $m$ masa človeka v kilogramih in $h$ njegova višina v metrih, izračunamo ITM po naslednji formuli: $ITM = \frac{m}{h^2}$.

Težo, ki je podana v kilogramih, imamo zapisano v spremenljivki masa. Višino, ki je podana v centimetrih, pa imamo v spremenljivki visina. Sestavite program, ki prebere težo in višino, izračuna ITM in vam pove, v kateri razred prehranjenosti spadate. Izračunani ITM izpišite na dve decimalni mesti natančno, tako da uporabite funkcijo dve_decimalki

  def dve_decimalki(x):
     """ Funkcija vrne niz, ki vsebuje zapis decimalnega števila x
         na dve decimalni mesti natančno.  """
     return '{0:.2f}'.format(x)

Izpis naj bo sledeč:

$ITM < 18.5$: Ti si podhranjen.
$18.5 \leq ITM < 25$: Ti si normalno prehranjen.
$25 \leq ITM < 30$: Ti si čezmerno prehranjen.
$30 \leq ITM$: Ti si debel.

Primer: Za podatke masa = 82.5, visina = 185.3 naj program izpiše:

>>>Vnesi težo: 82.5
Vnesi višino: 185.3
Tvoj ITM: 24.03
Ti si normalno prehranjen.

Uradna rešitev

def dve_decimalki(x):
     """
     Funkcija vrne niz, ki vsebuje zapis decimalnega števila x na dve
     decimalni mesti natančno.
     """
     return '{0:.2f}'.format(x)

masa = float(input('Vnesi težo: '))
visina = float(input('Vnesi višino: '))

itm = masa / (visina / 100)**2
print('Tvoj ITM:', dve_decimalki(itm))
if itm < 18.5:
    print('Ti si podhranjen.')
elif itm < 25:
    print('Ti si normalno prehranjen.')
elif itm < 30:
    print('Ti si čezmerno prehranjen.')
else:
    print('Ti si debel.')

Ednina, dvojina, množina

1. podnaloga

Napiši funkcijo finStanje(n), ki kot argument sprejme količino denarja na bančnem računu, podano v evrih (celih) in slovničnemu številu ustrezno vrne opis finančnega stanja.

 >>>finStanje(1)
 Stanje: 1 evro.
 >>>finStanje(1002)
 Stanje: 1002 evra.
 >>>finStanje(-203)
 Stanje: -203 evri.
 >>>finStanje(215)
 Stanje: 215 evrov.

Primer, če je vneseno stanje večje ali enako 1000000 evrov:

 >>>finStanje(1000002)
 Tajkun!

Primer, če je vneseno stanje nižje od -300 evrov:

 >>>finStanje(-302)
 Ti si navadna zguba!

Uradna rešitev

def finStanje(n):
    '''vrne opis finančnega stanja'''
    if n <-300:
        return 'Ti si navadna zguba!'
    if n >= 1000000:
        return 'Tajkun!'
    if abs(n)%100 == 1:
        return 'Stanje: ' + str(n) +' evro.'
    if abs(n)%100 == 2:
        return 'Stanje: ' + str(n) + ' evra.'
    if abs(n)%100 == 3 or abs(n)%100 == 4:
        return 'Stanje: ' + str(n) + ' evri.'
    return 'Stanje: ' + str(n) + ' evrov.'

2. podnaloga

Sestavi funkcijo stLjudi(n), ki kot argument sprejme poljubno naravno število in nato v slovnično pravilni obliki vrne opis števila ljudi v dvorani kulturnega doma (glej zglede). Dvorana sprejme največ 500 ljudi. Podatki so simeslni, torej celo število, večje ali enako 0. Primer za n=0:

 Dvorana je prazna.

Primer za n=1:

 V dvorani je 1 človek.

Primer za n=303:

 V dvorani so 303 ljudje.

Primer za n=500:

 Dvorana je polna.

Primer za n=502:

 Dvorana je polna. Zunaj sta ostala 2 človeka.

Uradna rešitev

def stLjudi(n):
    '''vrne niz z opisom števila ljudi v dvorani'''

    if n == 0:
        return 'Dvorana je prazna.'
    if n < 500:
        if n%100 == 1:
            return 'V dvorani je '+ str(n) + ' človek.'
        elif n%100 == 2:
            return 'V dvorani sta '+ str(n) + ' človeka.'
        elif n%100 == 3 or n%100==4:
            return 'V dvorani so '+ str(n) + ' ljudje.'
        else:
            return 'V dvorani je '+ str(n) + ' ljudi.'
    if n==500:
        return 'Dvorana je polna.'
    # več kot 500!
    if n%100 == 1:
        return 'Dvorana je polna. Zunaj je ostal '+ str(n-500)+' človek.'
    elif n%100 == 2:
        return 'Dvorana je polna. Zunaj sta ostala '+ str(n-500)+' človeka.'
    elif n%100 == 3 or n%100 == 4:
        return 'Dvorana je polna. Zunaj so ostali '+ str(n-500)+' ljudje.'
    else:
        return 'Dvorana je polna. Zunaj je ostalo '+ str(n-500)+' ljudi.'

3. podnaloga

Sestavite program, ki prebere naravno število n in nato izpiše niz oblike

Koliko imaš limon: 103
Imaš 103 limone.
Koliko imaš limon: 0
Imaš 0 limon.

pri čemer mora biti seveda vse pravilno sklanjano.

Uradna rešitev

n = int(input('Koliko imaš limon: '))
ostanek = n % 100
if ostanek == 1:
    koncnica = 'o'
elif ostanek == 2:
    koncnica = 'i'
elif ostanek == 3 or ostanek == 4:
    koncnica = 'e'
else:
    koncnica = ''
print("Imaš {0} limon{1}.".format(n, koncnica))

Biokosmiči

Skupina slovenskih nadebudnih mladih inovatorjev se je domislila projekta biokosmiči. Vrečke, v kateri so shranjeni kosmiči, ni potrebno odpirati, saj se v vodi raztopi. Vrečka je užitna in brez okusa.

1. podnaloga

Sestavite funkcijo nakup(imam, rabim, vrecka), ki izračuna, najmanj koliko vrečk kosmičev moramo kupiti, če jih že imamo imam gramov, potrebujemo jih rabim gramov, v posamezni vrečki pa je zapakirano vrecka gramov. Primer:

>>> nakup(4, 10, 3)
2

Uradna rešitev

def nakup(imam, rabim, vrecka):
    '''Koliko vrečk kosmičev je potrebno še kupiti'''
    if imam >= rabim:
        return 0 # imam več kot rabim ali ravno toliko 
    if (rabim - imam) % vrecka == 0: # v vrečkah je za naše potrebe po idealno kosmičev
        return (rabim - imam) // vrecka
    return (rabim - imam) // vrecka + 1 # če se ne izide, je potrebno kupiti še dodatno

2. podnaloga

Vsaka vrečka vsebuje 125 g kosmičev, ki so sestavljeni iz 80 g ovsenih kosmičev, 20 g rozin in 25 g oreščkov. Imamo že kosmici gramov ovsenih kosmičev, rozine gramov rozin in orescki gramov oreščkov. Sestavite funkcijo napolni(kosmici, rozine, orescki, n), ki izračuna, koliko gramov ovsenih kosmičev, rozin in oreščkov moramo še kupiti, da bomo lahko napolnili n vrečk kosmičev (funkcija mora vrniti trojico vrednosti). Primer:

>>> napolni(300, 0, 65, 3)
(0, 60, 10)

Uradna rešitev

def napolni(kosmici, rozine, orescki, n):
    '''Koliko sestavin je še potrebnih za n vrečk'''
    vreckaKosmici = 80
    vreckaRozine = 20
    vreckaOrescki = 25
    n1 = max(0, vreckaKosmici * n - kosmici)
    n2 = max(0, vreckaRozine * n - rozine)
    n3 = max(0, vreckaOrescki * n - orescki)
    return n1, n2, n3

3. podnaloga

Sestavite funkcijo napolni2(kosmici, rozine, orescki), ki izračuna, najmanj koliko vrečk kosmičev moramo napolniti, da bomo porabili vse sestavine. Imamo že kosmici gramov ovsenih kosmičev, rozine gramov rozin in orescki gramov oreščkov. Manjkajoče sestavine lahko pri tem dokupimo. Primer:

>>> napolni2(100, 40, 65)
3

Uradna rešitev

def napolni2(kosmici, rozine, orescki):
    '''Koliko vrečk potrebujemo, da porabimo prav vse sestavine'''
    vreckaKosmici = 80
    vreckaRozine = 20
    vreckaOrescki = 25
    potrebnoZaKosmice = kosmici // vreckaKosmici
    potrebnoZaRozine = rozine // vreckaRozine
    potrebnoZaOrescke = orescki // vreckaOrescki
    # če se s sestavinami ne sezide, bomo potrebovali še eno vrečko
    if kosmici % vreckaKosmici > 0: potrebnoZaKosmice += 1
    if rozine % vreckaRozine > 0: potrebnoZaRozine += 1
    if orescki % vreckaOrescki > 0: potrebnoZaOrescke += 1
    # vzamemo največje število potrebnih vrečk
    return max(potrebnoZaKosmice, potrebnoZaRozine, potrebnoZaOrescke)

Dolžinske enote

1. podnaloga

Sestavite funkcijo milimetri(kolicina, enota), ki razdaljo, podano z argumentoma kolicina in enota, pretvori v milimetre. Pri tem je kolicina neko število, enota pa je eden od nizov 'm', 'dm', 'cm' ali 'mm', ki predstavlja enoto. Primer:

>>> milimetri(3, 'm')
3000
>>> milimetri(15, 'cm')
150

Uradna rešitev

def milimetri(kolicina, enota):
    '''Koliko mm je to?'''
    if enota == 'm':
        odg = 1000 * kolicina
    elif enota == 'dm':
        odg = 100 * kolicina
    elif enota == 'cm':
        odg = 10 * kolicina
    else:
        odg = kolicina
    return odg

def milimetriV2(kolicina, enota):
    '''Koliko mm je to?'''
    if enota == 'm':
        odg = 1000 * kolicina
    elif enota == 'dm':
        odg = 100 * kolicina
    elif enota == 'cm':
        odg = 10 * kolicina
    else:
        odg = kolicina
    return odg

2. podnaloga

Sestavite funkcijo milimetriV2(kolicina, enota), ki razdaljo, podano z argumentoma kolicina in enota, pretvori v milimetre. Pri tem je kolicina neko število, enota pa je zagotovo eden od nizov 'm', 'dm', 'cm' ali 'mm', ki predstavlja enoto. Primer:

>>> milimetri(3, 'm')
3000
>>> milimetri(15, 'cm')
150

Pri tem ne smeš uporabiti ne gnezdenih stavkov if, ne dela else. Namig: v funkciji imamo lahko več ukazov return

Uradna rešitev

def milimetriV2(kolicina, enota):
    '''Koliko mm je to?'''
    if enota == 'm':
        return 1000 * kolicina
    # če smo prišli sem - m zagotovo niso
    if enota == 'dm':
        return 100 * kolicina
    if enota == 'cm':
        return 10 * kolicina
    # torej gre za mm
    return kolicina

3. podnaloga

Sestavite funkcijo primerjaj(mera1, enota1, mera2, enota2), ki za dve podani razdalji pove, katera je večja. Prva razdalja je podana v spremenljivkah mera1 in enota1, druga pa v spremenljivkah mera2 in enota2

Funkcija naj vrne prva, če je prva razdalja večja od druge; enaki, če sta razdalji enaki in druga, če je druga razdalja večja od prve. Primer:

>>> primerjaj(2, 'm', 3, 'm')
druga
>>> primerjaj(1, 'm', 100, 'cm')
enaki

Uradna rešitev

def primerjaj(mera1, enota1, mera2, enota2):
    '''Katera razdalja je večja'''
    # pretvorimo obe razdalji v mm
    razlika = milimetri(mera1, enota1) - milimetri(mera2, enota2)
    if razlika > 0:
        return 'prva'
    if razlika < 0:
        return 'druga'
    # ni se izvedel noben izmed gornjih ukazov return, torej ni bil izpolnjen noben pogoj...
    return 'enaki'

4. podnaloga

Sestavite funkcijo primerjajEnoti(enota1, enota2), ki za dve dolžinski enoti pove, katera je večja. Funkcija naj vrne 1, če je prva enota večja od druge, 0, če sta enoti enaki, in -1, če je druga enota večja od prve. Primer:

>>> primerjajEnoti('dm', 'cm')
1
>>> primerjajEnoti('mm', 'm')
-1

Namig: Neposredno primerjanje nizov bo dalo napačen rezultat!

Uradna rešitev

def primerjajEnoti(enota1, enota2):
    '''1 - večja je enota1
       0 - enaki enoti
       -1 - večja je enota2 '''
    primerjava = primerjaj(1, enota1, 1, enota2) # uporabimo funkcijo prejšnje naloge
    if primerjava == 'prva':
        return 1
    if primerjava == 'druga':
        return -1
    return 0

Indiana Jones

1. podnaloga

Indiana Jones najde v starem templju tri zlate kipce, ker pa ima samo dve roki, mora enega, katerega vrednost je najmanjša, pustiti tam. Sestavi funkcijo indiana(stevilo1, stevilo2, stevilo3), ki kot argumente sprejme vrednosti kipcev ter vrne podatek (niz) katera dva kipca se najbolj splača vzeti s sabo.

Možne rešitve so:

če so vrednosti kipcev različne, ali če se dve vrednosti ponovita in sta večji od tretje:

"Vzeti mora kipca 2 in 3."
"Vzeti mora kipca 1 in 3."
"Vzeti mora kipca 1 in 2."

če so vrednosti vseh kipcev enake:

"Vzame lahko katerakoli dva kipca."

če se dve vrednosti ponovita in sta manjši od tretje:

"Vzeti mora kipec 3 ter enega od preostalih dveh."
"Vzeti mora kipec 2 ter enega od preostalih dveh."
"Vzeti mora kipec 1 ter enega od preostalih dveh."

Uradna rešitev

def indiana(stevilo1, stevilo2, stevilo3):
    '''vrne podatek, katera kipca se splača vzeti'''
        
    #če so vrednosti vseh kipcev enake, vzamemo poljubna kipca
    if stevilo1 == stevilo2 == stevilo3:
        return "Vzame lahko katerakoli dva kipca."
    
    #če je vrednost prvega kipca manjša od ostalih, izločimo prvi kipec
    #podobno naprej
    if stevilo1 < min(stevilo2, stevilo3):
        return "Vzeti mora kipca 2 in 3."
    if stevilo2 < min(stevilo1, stevilo3):
        return "Vzeti mora kipca 1 in 3."
    if stevilo3 < min(stevilo1, stevilo2):
        return "Vzeti mora kipca 1 in 2."

        
    #če se dve vrednosti ponovita, potem ločimo primer, ko je tretja vrednost ali večja ali manjša od prvih dveh
    #če je manjša, vzamemo kipca s prvima dvema vrednostima
    #če je večja, vzamemo kipec s tretjo vrednostjo in izbiramo med ostalima kipcema
    if (stevilo1 == stevilo2) and (stevilo3 != stevilo2):
        if stevilo1 < stevilo3:
            return "Vzeti mora kipec 3 ter enega od preostalih dveh."
        else:
            return "Vzeti mora kipca 1 in 2."
    if (stevilo1 == stevilo3) and (stevilo3 != stevilo2):
        if stevilo1 < stevilo2:
            return "Vzeti mora kipec 2 ter enega od preostalih dveh."
        else:
            return "Vzeti mora kipca 1 in 3."
    if (stevilo2 == stevilo3) and (stevilo1 != stevilo2):
        if stevilo2 < stevilo1:
            return "Vzeti mora kipec 1 ter enega od preostalih dveh."
        else:
            return "Vzeti mora kipca 2 in 3."

2. podnaloga

Sedaj pa sestavi funkcijo izguba(stevilo1, stevilo2, stevilo3), ki kot argumente sprejme vrednosti kipcev ter vrne koliko bo Indiana Jones žal moral pustiti v templju Tako:

     >>>izguba(7, 2, 3)
     2
     >>>izguba(7, 8, 7)
     7

Uradna rešitev

def izguba(stevilo1, stevilo2, stevilo3):
    '''vrne vrednost, ki jo bo Indiana Jones moral pustiti'''
    return min(stevilo1, stevilo2, stevilo3)

3. podnaloga

Sedaj pa sestavi funkcijo kateriVrednosti(stevilo1, stevilo2, stevilo3), ki kot argumente sprejme vrednosti kipcev ter vrne po velikosti urejen par vrednosti kipcev, ki ju bo Indiana Jones vzel Tako:

     >>>kateriVrednosti(7, 2, 3)
     (3, 7)
     >>>kateriVrednosti(7, 8, 7)
     (7, 8)

Uradna rešitev

def kateriVrednosti(stevilo1, stevilo2, stevilo3):
    '''vrne vrednost, ki jo bo Indiana Jones moral pustiti'''
    najv = max(stevilo1, stevilo2, stevilo3)
    najm = min(stevilo1, stevilo2, stevilo3)
    srednje = stevilo1 + stevilo2 + stevilo3 - najv - najm
    return (srednje, najv)

Preseki in unije pravokotnikov

1. podnaloga

Sestavite funkcijo nad_interval(a1, b1, a2, b2), ki izračuna najmanjši interval, ki vsebuje intervala $[a_1, b_1]$ in $[a_2, b_2]$. Funkcija naj vrne par števil, ki predstavlja krajišča intervala.

Primer:

>>> nad_interval(3, 7, 1, 2)
(1, 7)
>>> nad_interval(3, 7, 1, 5)
(1, 7)
>>> nad_interval(3, 7, 7, 8)
(3, 8)

Uradna rešitev

def nad_interval(a1, b1, a2, b2):
    '''interval, ki vsebuje oba dana intervala'''
    a3 = min(a1, a2)
    b3 = max(b1, b2)
    return (a3, b3)

2. podnaloga

Sestavite funkcijo presek_intervalov(a1, b1, a2, b2), ki izračuna največji interval, vsebovan v intervalih $[a_1, b_1]$ in $[a_2, b_2]$, torej njun presek. Če je presek neprazen, naj funkcija vrne par števil, ki predstavlja krajišča intervala, sicer pa naj funkcija vrne par (0,-1).

Primer:

>>> presek_intervalov(3, 7, 1, 2)
(0,-1)
>>> presek_intervalov(3, 7, 1, 5)
(3, 5)
>>> presek_intervalov(3, 7, 7, 8)
(7, 7)

Uradna rešitev

def presek_intervalov(a1, b1, a2, b2):
    '''Vrne presek intervalov (če obstaja), sicer pa (0,-1)''' 
    a3 = max(a1, a2)
    b3 = min(b1, b2)
    if a3 > b3:
        return (0,-1)
    else:
        return (a3, b3)

3. podnaloga

Sestavi funkcijo pravokotnika(a1x, a1y, b1x, b1y, a2x, a2y, b2x, b2y), ki bo izračunala obseg in površino unije dveh pravokotnikov. Stranice pravokotnikov so vzporedne koordinatnima osema. Vsak pravokotnik je podan s koordinatami (katerihkoli) dveh nasprotnih si oglišč.

Primer:

>>> pravokotnika(1, 1, 5, 5, 6, 8, 8, 3)
(30, 26)
>>> pravokotnika(1, 1, 5, 5, 4, 8, 8, 3)
(28, 34)

Uradna rešitev

def pravokotnika(a1x, a1y, b1x, b1y, a2x, a2y, b2x, b2y):
    '''Izračuna obseg in površino unije dveh pravokotnikov'''
    # poskrbimo, da je A1 levo spodaj in B1 desno zgoraj
    if a1x > b1x:
        a1x, b1x = b1x, a1x
    if a1y > b1y:
        a1y, b1y = b1y, a1y
    # poskrbimo, da je A2 levo spodaj in B3 desno zgoraj
    if a2x > b2x:
        a2x, b2x = b2x, a2x
    if a2y > b2y:
        a2y, b2y = b2y, a2y
        
    # določimo točki, ki določata presek A3 je levo spodaj in B3 desno zgoraj
    # če preseka ni, sta seveda ti točki "čudni"
    ax3 = max(a1x, a2x)
    ay3 = max(a1y, a2y)
    bx3 = min(b1x, b2x)
    by3 = min(b1y, b2y)

    # izračunamo ploščino prvega in drugega pravok
    pl1 = (b1x - a1x) * (b1y - a1y)
    pl2 = (b2x - a2x) * (b2y - a2y)
    ob1 = 2 * ((b1x - a1x) + (b1y - a1y))
    ob2 = 2 * ((b2x - a2x) + (b2y - a2y))

    # izračunamo pl in obseg preseka
    pl3 = 0
    ob3 = 0
    # pogledamo, če sploh presek je! Dovolimo tudi samo črto (torej če ene stranuice "ni")!
    if bx3 >= ax3 and by3 >= ay3:
        pl3 = (bx3 - ax3) * (by3 - ay3)
        ob3 = 2 * ((bx3 - ax3) + (by3 - ay3))

    obsegRezultata = ob1 + ob2 - ob3
    ploscinaRezultata = pl1 + pl2 - pl3
    

    return(obsegRezultata, ploscinaRezultata)

Bratska igra

Za nalogo potrebuješ le znanje definiranja funkcij in stavka if

1. podnaloga

Matej se rad igra s kamenčki in jih cel dan nabira naokrog. Zvečer pa ga neskončno zabava, ko njegov mljši brat poskuša uganiti, koliko jih je nabral.

Če brat pove premajhno število, mu Matej odgovori 'več', če pove preveliko število, mu Matej odgovori 'manj', če pa število ugane mu Matej odgovori 'točno'.

Setavite funkcijo ugibaj(matej, brat), ki simulira en korak zgornje igre. Funkcija naj Matejev odgovor vrne kot niz.

Primer:

>>> ugibaj(8, 5)
'več'

Uradna rešitev

def ugibaj(matej, brat):
  '''Kako odgovori Matej'''
  if matej > brat:
    return 'več'
  elif matej < brat:
    return 'manj'
  else:
    return 'točno'

2. podnaloga

Da bi igro popestril, je Matej razdelil kamenčke v obe roki, brat pa mora uganiti število kamenčkov v vsaki roki posebej. Ob vsakem poskusu Matej za vsako izmed rok izračuna absolutno razliko med pravim številom kamenčkov in bratovim poskusom ter bratu pove manjše izmed teh dveh števil.

Sestavite funkcijo ugibaj1(matejLR, matejDR, bratLR, bratDR), ki sprejme štiri nenegativna cela števila in Matejev odgovor vrne kot število. Če brat ugane obe števili, naj funkcija vrne -100. Primer:

>>> ugibaj1(8, 10, 5, 3)
5

Uradna rešitev

import math 

def ugibaj1(matejLr, matejDr, bratLr, bratDr):
  '''Kakšna je največja razlika'''
  razlika1 = abs(matejLr - bratLr)
  razlika2 = abs(matejDr - bratDr)
  najvecja = min(razlika1, razlika2)
  if najvecja == 0: # uganjeni sta obe
    return -100
  return najvecja

3. podnaloga

Zgornja igra pa ni bila preveč všeč Matejevemu bratu, saj je običajno trajala predolgo in je zato brat še pred koncem igre že zaspal. Zato je od Mateja zahteval, da mu za vsako roko pove še, ali je število kamenčkov v njej večje, manjše oz. enako ugibanemu. Mateju pa se je to zdelo preveč, zato sta se odločila za kompromis: Matej bo bratu povedal le, ali je brat obakrat povedal preveliko število, obakrat premajhno ali pa enkrat premajhno in drugič preveliko. Ustrezni Matejevi odgovori so 'Obakrat preveč.', 'Obakrat premalo.' in 'Preveč in premalo.'. Če brat ugane eno izmed števil, drugega pa ne, se Matej pretvarja, kot da je brat namesto pravega števila povedal preveliko število.

Sestavite funkcijo ugibaj2(matejLr, matejDr, bratLr, bratDr), ki sprejme štiri nenegativna cela števila in Matejev odgovor vrne kot niz. Če brat ugane obe števili, naj funkcija vrne niz 'Bravo!'

Primer:

>>> ugibaj2(4, 3, 4, 6)
'Obakrat preveč'

Uradna rešitev

def ugibaj2(matejLr, matejDr, bratLr, bratDr):
  '''Kaj odgovori Matej'''
  razlika1 = bratLr - matejLr
  razlika2 = bratDr - matejDr
  
  if razlikaLr == 0 and razlikaDr == 0:
    return 'Bravo!'
  elif razlikaLr >= 0 and razlikaDr >= 0:
    return 'Obakrat preveč.'
  elif razlikaLr < 0 and razlikaDr < 0:
    return 'Obakrat premalo.'
  else:
    return 'Preveč in premalo.'

def ugibaj2(matejLr, matejDr, bratLr, bratDr):
  '''Kaj odgovori Matej'''
  # za razliko od prej, upoštevamo, da return zaključi funkcijo, torej ne potrebujemo elif

  razlikaLr = bratLr - matejLr
  razlikaDr = bratDr - matejDr
  
  if razlikaLr == 0 and razlikaDr == 0:
    return 'Bravo!'
  if razlikaLr >= 0 and razlikaDr >= 0:
    return 'Obakrat preveč.'
  if razlikaLr < 0 and razlikaDr < 0:
    return 'Obakrat premalo.'
  return 'Preveč in premalo.'